// 用户服务层 - 处理用户相关的业务逻辑
const 获取用户模型 = require('../models/User');
const 数据库操作 = require('../zh/后端/数据库操作');
const { 操作符 } = require('../config/db');

// 动态获取用户模型
function 获取用户() {
  return 获取用户模型();
}

/**
 * 用户服务类 - 使用Sequelize实现
 */
class 用户服务 {
  /**
   * 根据ID查找用户
   * @param {number} 用户ID - 用户的唯一标识
   * @returns {Promise<Object|null>} 用户信息对象或null
   */
  static async 根据ID查找用户(用户ID) {
    try {
      const 用户 = await 数据库操作.根据ID查询(获取用户(), 用户ID);
      return 用户 ? 用户.toJSON() : null;
    } catch (错误) {
      console.error('根据ID查找用户失败:', 错误);
      throw new Error('查找用户失败');
    }
  }

  /**
   * 根据用户名查找用户
   * @param {string} 用户名 - 用户名
   * @returns {Promise<Object|null>} 用户信息对象或null
   */
  static async 根据用户名查找用户(用户名) {
    try {
      const 用户 = await 数据库操作.根据条件查询(获取用户(), { 用户名 });
      return 用户 ? 用户.toJSON() : null;
    } catch (错误) {
      console.error('根据用户名查找用户失败:', 错误);
      throw new Error('查找用户失败');
    }
  }

  /**
   * 创建新用户
   * @param {Object} 用户数据 - 用户信息
   * @returns {Promise<Object>} 创建的用户信息
   */
  static async 创建用户(用户数据) {
    try {
      // 检查用户名是否已存在
      const 现有用户 = await 数据库操作.根据条件查询(获取用户(), { 用户名: 用户数据.用户名 });
      if (现有用户) {
        throw new Error('用户名已存在');
      }

      // 检查邮箱是否已存在
      const 邮箱用户 = await 数据库操作.根据条件查询(获取用户(), { 邮箱: 用户数据.邮箱 });
      if (邮箱用户) {
        throw new Error('邮箱已被注册');
      }

      // 创建用户数据
      const 创建数据 = {
        用户名: 用户数据.用户名,
        密码: 用户数据.密码, // 密码会在模型的beforeCreate钩子中自动哈希
        昵称: 用户数据.昵称 || 用户数据.用户名,
        邮箱: 用户数据.邮箱,
        角色: 用户数据.角色 || '用户',
        状态: '活跃'
      };

      // 保存到数据库
      const 保存的用户 = await 数据库操作.创建记录(获取用户(), 创建数据);
      return 保存的用户.toJSON();
    } catch (错误) {
      console.error('创建用户失败:', 错误);
      throw 错误; // 直接抛出错误，让控制器处理
    }
  }

  /**
   * 用户登录认证
   * @param {string} 用户名 - 用户名
   * @param {string} 密码 - 密码
   * @returns {Promise<Object>} 登录结果
   */
  static async 用户登录(用户名, 密码) {
    try {
      // 查找用户
      const 用户 = await 数据库操作.根据条件查询(获取用户(), { 用户名 });
      
      // 检查用户是否存在
      if (!用户) {
        throw new Error('用户名或密码错误');
      }
      
      // 检查用户状态
      if (用户.状态 !== '活跃') {
        throw new Error('账户已被禁用');
      }
      
      // 检查密码
      const 密码正确 = await 用户.验证密码(密码);
      if (!密码正确) {
        throw new Error('用户名或密码错误');
      }
      
      // 更新登录信息
      用户.最后登录时间 = new Date();
      用户.登录次数 += 1;
      await 用户.save();
      
      return {
        success: true,
        用户: 用户.toJSON()
      };
    } catch (错误) {
      console.error('用户登录失败:', 错误);
      throw 错误;
    }
  }

  /**
   * 更新用户信息
   * @param {number} 用户ID - 用户ID
   * @param {Object} 更新数据 - 要更新的数据
   * @returns {Promise<Object|null>} 更新后的用户信息
   */
  static async 更新用户(用户ID, 更新数据) {
    try {
      // 检查用户是否存在
      const 用户 = await 数据库操作.根据ID查询(获取用户(), 用户ID);
      if (!用户) {
        throw new Error('用户不存在');
      }
      
      // 过滤敏感字段，不允许直接更新
      const 允许更新字段 = ['昵称', '邮箱', '头像', '角色', '状态'];
      const 过滤后的更新 = {};
      
      for (const 字段 of 允许更新字段) {
        if (更新数据[字段] !== undefined) {
          过滤后的更新[字段] = 更新数据[字段];
        }
      }
      
      // 更新用户信息
      await 数据库操作.更新记录(获取用户(), { id: 用户ID }, 过滤后的更新);
      // 重新获取更新后的用户信息
      const 更新后的用户 = await 数据库操作.根据ID查询(获取用户(), 用户ID);
      return 更新后的用户 ? 更新后的用户.toJSON() : null;
    } catch (错误) {
      console.error('更新用户失败:', 错误);
      throw 错误;
    }
  }

  /**
   * 获取用户列表
   * @param {Object} 查询条件 - 查询参数
   * @returns {Promise<Object>} 用户列表和分页信息
   */
  static async 获取用户列表(分页 = { 页号: 1, 每页数量: 10 }, 查询条件 = {}) {
    try {
      const { 页号, 每页数量 } = 分页;
      const 偏移量 = (页号 - 1) * 每页数量;
      
      // 构建查询条件
      const where = {};
      if (查询条件.状态) {
        where.状态 = 查询条件.状态;
      }
      if (查询条件.角色) {
        where.角色 = 查询条件.角色;
      }
      if (查询条件.关键词) {
        where[操作符.或] = [
          { 用户名: { [操作符.喜欢]: `%${查询条件.关键词}%` } },
          { 昵称: { [操作符.喜欢]: `%${查询条件.关键词}%` } },
          { 邮箱: { [操作符.喜欢]: `%${查询条件.关键词}%` } }
        ];
      }
      
      // 执行查询
      const { rows: 数据, count: 总数 } = await 数据库操作.查询并计数(获取用户(), {
        where,
        offset: 偏移量,
        limit: 每页数量,
        order: [['创建时间', 'DESC']]
      });
      
      return {
        数据: 数据.map(用户 => 用户.toJSON()),
        分页: {
          页号,
          每页数量,
          总数,
          总页数: Math.ceil(总数 / 每页数量)
        }
      };
    } catch (错误) {
      console.error('获取用户列表失败:', 错误);
      throw new Error('获取用户列表失败');
    }
  }

  /**
   * 禁用用户
   * @param {number} 用户ID - 用户ID
   * @returns {Promise<boolean>} 是否成功
   */
  static async 禁用用户(用户ID) {
    try {
      return await 数据库操作.更新记录(获取用户(), { id: 用户ID }, { 状态: '禁用' });
    } catch (错误) {
      console.error('禁用用户失败:', 错误);
      throw new Error('禁用用户失败');
    }
  }

  /**
   * 启用用户
   * @param {number} 用户ID - 用户ID
   * @returns {Promise<boolean>} 是否成功
   */
  static async 启用用户(用户ID) {
    try {
      return await 数据库操作.更新记录(获取用户(), { id: 用户ID }, { 状态: '活跃' });
    } catch (错误) {
      console.error('启用用户失败:', 错误);
      throw new Error('启用用户失败');
    }
  }
}

module.exports = 用户服务;